module fairygui {

    
    // wrapper for non-node envs
    ;(function (sax) {
    
    sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }
    sax.SAXParser = SAXParser
    sax.SAXStream = SAXStream
    sax.createStream = createStream
    
    // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
    // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
    // since that's the earliest that a buffer overrun could occur.  This way, checks are
    // as rare as required, but as often as necessary to ensure never crossing this bound.
    // Furthermore, buffers are only tested at most once per write(), so passing a very
    // large string into write() might have undesirable effects, but this is manageable by
    // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
    // edge case, result in creating at most one complete copy of the string passed in.
    // Set to Infinity to have unlimited buffers.
    sax.MAX_BUFFER_LENGTH = 64 * 1024
    
    var buffers = [
      "comment", "sgmlDecl", "textNode", "tagName", "doctype",
      "procInstName", "procInstBody", "entity", "attribName",
      "attribValue", "cdata", "script"
    ]
    
    sax.EVENTS = // for discoverability.
      [ "text"
      , "processinginstruction"
      , "sgmldeclaration"
      , "doctype"
      , "comment"
      , "attribute"
      , "opentag"
      , "closetag"
      , "opencdata"
      , "cdata"
      , "closecdata"
      , "error"
      , "end"
      , "ready"
      , "script"
      , "opennamespace"
      , "closenamespace"
      ]
    
    function SAXParser (strict, opt) {
      if (!(this instanceof SAXParser)) return new SAXParser(strict, opt)
    
      var parser = this
      clearBuffers(parser)
      parser.q = parser.c = ""
      parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH
      parser.opt = opt || {}
      parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags
      parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase"
      parser.tags = []
      parser.closed = parser.closedRoot = parser.sawRoot = false
      parser.tag = parser.error = null
      parser.strict = !!strict
      parser.noscript = !!(strict || parser.opt.noscript)
      parser.state = S.BEGIN
      parser.ENTITIES = Object.create(sax.ENTITIES)
      parser.attribList = []
    
      // namespaces form a prototype chain.
      // it always points at the current tag,
      // which protos to its parent tag.
      if (parser.opt.xmlns) parser.ns = Object.create(rootNS)
    
      // mostly just for error reporting
      parser.trackPosition = parser.opt.position !== false
      if (parser.trackPosition) {
        parser.position = parser.line = parser.column = 0
      }
      emit(parser, "onready")
    }
    
    if (!Object.create) Object.create = function (o) {
      function f () { this.__proto__ = o }
      f.prototype = o
      return new f
    }
    
    if (!Object.getPrototypeOf) Object.getPrototypeOf = function (o) {
      return o.__proto__
    }
    
    if (!Object.keys) Object.keys = function (o) {
      var a = []
      for (var i in o) if (o.hasOwnProperty(i)) a.push(i)
      return a
    }
    
    function checkBufferLength (parser) {
      var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)
        , maxActual = 0
      for (var i = 0, l = buffers.length; i < l; i ++) {
        var len = parser[buffers[i]].length
        if (len > maxAllowed) {
          // Text/cdata nodes can get big, and since they're buffered,
          // we can get here under normal conditions.
          // Avoid issues by emitting the text node now,
          // so at least it won't get any bigger.
          switch (buffers[i]) {
            case "textNode":
              closeText(parser)
            break
    
            case "cdata":
              emitNode(parser, "oncdata", parser.cdata)
              parser.cdata = ""
            break
    
            case "script":
              emitNode(parser, "onscript", parser.script)
              parser.script = ""
            break
    
            default:
              error(parser, "Max buffer length exceeded: "+buffers[i])
          }
        }
        maxActual = Math.max(maxActual, len)
      }
      // schedule the next check for the earliest possible buffer overrun.
      parser.bufferCheckPosition = (sax.MAX_BUFFER_LENGTH - maxActual)
                                 + parser.position
    }
    
    function clearBuffers (parser) {
      for (var i = 0, l = buffers.length; i < l; i ++) {
        parser[buffers[i]] = ""
      }
    }
    
    function flushBuffers (parser) {
      closeText(parser)
      if (parser.cdata !== "") {
        emitNode(parser, "oncdata", parser.cdata)
        parser.cdata = ""
      }
      if (parser.script !== "") {
        emitNode(parser, "onscript", parser.script)
        parser.script = ""
      }
    }
    
    SAXParser.prototype =
      { end: function () { end(this) }
      , write: write
      , resume: function () { this.error = null; return this }
      , close: function () { return this.write(null) }
      , flush: function () { flushBuffers(this) }
      }
    

    var Stream = function () {}
    
    var streamWraps = sax.EVENTS.filter(function (ev) {
      return ev !== "error" && ev !== "end"
    })
    
    function createStream (strict, opt) {
      return new SAXStream(strict, opt)
    }
    
    function SAXStream (strict, opt) {
      if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)
    
      Stream.apply(this)
    
      this._parser = new SAXParser(strict, opt)
      this.writable = true
      this.readable = true
    
    
      var me = this
    
      this._parser.onend = function () {
        me.emit("end")
      }
    
      this._parser.onerror = function (er) {
        me.emit("error", er)
    
        // if didn't throw, then means error was handled.
        // go ahead and clear error, so we can write again.
        me._parser.error = null
      }
    
      this._decoder = null;
    
      streamWraps.forEach(function (ev) {
        Object.defineProperty(me, "on" + ev, {
          get: function () { return me._parser["on" + ev] },
          set: function (h) {
            if (!h) {
              me.removeAllListeners(ev)
              return me._parser["on"+ev] = h
            }
            me.on(ev, h)
          },
          enumerable: true,
          configurable: false
        })
      })
    }
    
    SAXStream.prototype = Object.create(Stream.prototype,
      { constructor: { value: SAXStream } })
    
    SAXStream.prototype.write = function (data) {
    //   if (typeof Buffer === 'function' &&
    //       typeof Buffer.isBuffer === 'function' &&
    //       Buffer.isBuffer(data)) {
    //     if (!this._decoder) {
    //       var SD = require('string_decoder').StringDecoder
    //       this._decoder = new SD('utf8')
    //     }
    //     data = this._decoder.write(data);
    //   }
    
      this._parser.write(data.toString())
      this.emit("data", data)
      return true
    }
    
    SAXStream.prototype.end = function (chunk) {
      if (chunk && chunk.length) this.write(chunk)
      this._parser.end()
      return true
    }
    
    SAXStream.prototype.on = function (ev, handler) {
      var me = this
      if (!me._parser["on"+ev] && streamWraps.indexOf(ev) !== -1) {
        me._parser["on"+ev] = function () {
          var args = arguments.length === 1 ? [arguments[0]]
                   : Array.apply(null, arguments)
          args.splice(0, 0, ev)
          me.emit.apply(me, args)
        }
      }
    
      return Stream.prototype.on.call(me, ev, handler)
    }
    
    
    
    // character classes and tokens
    var whitespace = "\r\n\t "
      // this really needs to be replaced with character classes.
      // XML allows all manner of ridiculous numbers and digits.
      , number = "0124356789"
      , letter = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
      // (Letter | "_" | ":")
      , quote = "'\""
      , entity = number+letter+"#"
      , attribEnd = whitespace + ">"
      , CDATA = "[CDATA["
      , DOCTYPE = "DOCTYPE"
      , XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
      , XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"
      , rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
    
    // turn all the string character sets into character class objects.
    whitespace = charClass(whitespace)
    number = charClass(number)
    letter = charClass(letter)
    
    // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
    // This implementation works on strings, a single character at a time
    // as such, it cannot ever support astral-plane characters (10000-EFFFF)
    // without a significant breaking change to either this  parser, or the
    // JavaScript language.  Implementation of an emoji-capable xml parser
    // is left as an exercise for the reader.
    var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
    
    var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040\.\d-]/
    
    quote = charClass(quote)
    entity = charClass(entity)
    attribEnd = charClass(attribEnd)
    
    function charClass (str) {
      return str.split("").reduce(function (s, c) {
        s[c] = true
        return s
      }, {})
    }
    
    function isRegExp (c) {
      return Object.prototype.toString.call(c) === '[object RegExp]'
    }
    
    function is (charclass, c) {
      return isRegExp(charclass) ? !!c.match(charclass) : charclass[c]
    }
    
    function not (charclass, c) {
      return !is(charclass, c)
    }
    
    var S = 0
    sax.STATE =
    { BEGIN                     : S++
    , TEXT                      : S++ // general stuff
    , TEXT_ENTITY               : S++ // &amp and such.
    , OPEN_WAKA                 : S++ // <
    , SGML_DECL                 : S++ // <!BLARG
    , SGML_DECL_QUOTED          : S++ // <!BLARG foo "bar
    , DOCTYPE                   : S++ // <!DOCTYPE
    , DOCTYPE_QUOTED            : S++ // <!DOCTYPE "//blah
    , DOCTYPE_DTD               : S++ // <!DOCTYPE "//blah" [ ...
    , DOCTYPE_DTD_QUOTED        : S++ // <!DOCTYPE "//blah" [ "foo
    , COMMENT_STARTING          : S++ // <!-
    , COMMENT                   : S++ // <!--
    , COMMENT_ENDING            : S++ // <!-- blah -
    , COMMENT_ENDED             : S++ // <!-- blah --
    , CDATA                     : S++ // <![CDATA[ something
    , CDATA_ENDING              : S++ // ]
    , CDATA_ENDING_2            : S++ // ]]
    , PROC_INST                 : S++ // <?hi
    , PROC_INST_BODY            : S++ // <?hi there
    , PROC_INST_ENDING          : S++ // <?hi "there" ?
    , OPEN_TAG                  : S++ // <strong
    , OPEN_TAG_SLASH            : S++ // <strong /
    , ATTRIB                    : S++ // <a
    , ATTRIB_NAME               : S++ // <a foo
    , ATTRIB_NAME_SAW_WHITE     : S++ // <a foo _
    , ATTRIB_VALUE              : S++ // <a foo=
    , ATTRIB_VALUE_QUOTED       : S++ // <a foo="bar
    , ATTRIB_VALUE_CLOSED       : S++ // <a foo="bar"
    , ATTRIB_VALUE_UNQUOTED     : S++ // <a foo=bar
    , ATTRIB_VALUE_ENTITY_Q     : S++ // <foo bar="&quot;"
    , ATTRIB_VALUE_ENTITY_U     : S++ // <foo bar=&quot;
    , CLOSE_TAG                 : S++ // </a
    , CLOSE_TAG_SAW_WHITE       : S++ // </a   >
    , SCRIPT                    : S++ // <script> ...
    , SCRIPT_ENDING             : S++ // <script> ... <
    }
    
    sax.ENTITIES =
    { "amp" : "&"
    , "gt" : ">"
    , "lt" : "<"
    , "quot" : "\""
    , "apos" : "'"
    , "AElig" : 198
    , "Aacute" : 193
    , "Acirc" : 194
    , "Agrave" : 192
    , "Aring" : 197
    , "Atilde" : 195
    , "Auml" : 196
    , "Ccedil" : 199
    , "ETH" : 208
    , "Eacute" : 201
    , "Ecirc" : 202
    , "Egrave" : 200
    , "Euml" : 203
    , "Iacute" : 205
    , "Icirc" : 206
    , "Igrave" : 204
    , "Iuml" : 207
    , "Ntilde" : 209
    , "Oacute" : 211
    , "Ocirc" : 212
    , "Ograve" : 210
    , "Oslash" : 216
    , "Otilde" : 213
    , "Ouml" : 214
    , "THORN" : 222
    , "Uacute" : 218
    , "Ucirc" : 219
    , "Ugrave" : 217
    , "Uuml" : 220
    , "Yacute" : 221
    , "aacute" : 225
    , "acirc" : 226
    , "aelig" : 230
    , "agrave" : 224
    , "aring" : 229
    , "atilde" : 227
    , "auml" : 228
    , "ccedil" : 231
    , "eacute" : 233
    , "ecirc" : 234
    , "egrave" : 232
    , "eth" : 240
    , "euml" : 235
    , "iacute" : 237
    , "icirc" : 238
    , "igrave" : 236
    , "iuml" : 239
    , "ntilde" : 241
    , "oacute" : 243
    , "ocirc" : 244
    , "ograve" : 242
    , "oslash" : 248
    , "otilde" : 245
    , "ouml" : 246
    , "szlig" : 223
    , "thorn" : 254
    , "uacute" : 250
    , "ucirc" : 251
    , "ugrave" : 249
    , "uuml" : 252
    , "yacute" : 253
    , "yuml" : 255
    , "copy" : 169
    , "reg" : 174
    , "nbsp" : 160
    , "iexcl" : 161
    , "cent" : 162
    , "pound" : 163
    , "curren" : 164
    , "yen" : 165
    , "brvbar" : 166
    , "sect" : 167
    , "uml" : 168
    , "ordf" : 170
    , "laquo" : 171
    , "not" : 172
    , "shy" : 173
    , "macr" : 175
    , "deg" : 176
    , "plusmn" : 177
    , "sup1" : 185
    , "sup2" : 178
    , "sup3" : 179
    , "acute" : 180
    , "micro" : 181
    , "para" : 182
    , "middot" : 183
    , "cedil" : 184
    , "ordm" : 186
    , "raquo" : 187
    , "frac14" : 188
    , "frac12" : 189
    , "frac34" : 190
    , "iquest" : 191
    , "times" : 215
    , "divide" : 247
    , "OElig" : 338
    , "oelig" : 339
    , "Scaron" : 352
    , "scaron" : 353
    , "Yuml" : 376
    , "fnof" : 402
    , "circ" : 710
    , "tilde" : 732
    , "Alpha" : 913
    , "Beta" : 914
    , "Gamma" : 915
    , "Delta" : 916
    , "Epsilon" : 917
    , "Zeta" : 918
    , "Eta" : 919
    , "Theta" : 920
    , "Iota" : 921
    , "Kappa" : 922
    , "Lambda" : 923
    , "Mu" : 924
    , "Nu" : 925
    , "Xi" : 926
    , "Omicron" : 927
    , "Pi" : 928
    , "Rho" : 929
    , "Sigma" : 931
    , "Tau" : 932
    , "Upsilon" : 933
    , "Phi" : 934
    , "Chi" : 935
    , "Psi" : 936
    , "Omega" : 937
    , "alpha" : 945
    , "beta" : 946
    , "gamma" : 947
    , "delta" : 948
    , "epsilon" : 949
    , "zeta" : 950
    , "eta" : 951
    , "theta" : 952
    , "iota" : 953
    , "kappa" : 954
    , "lambda" : 955
    , "mu" : 956
    , "nu" : 957
    , "xi" : 958
    , "omicron" : 959
    , "pi" : 960
    , "rho" : 961
    , "sigmaf" : 962
    , "sigma" : 963
    , "tau" : 964
    , "upsilon" : 965
    , "phi" : 966
    , "chi" : 967
    , "psi" : 968
    , "omega" : 969
    , "thetasym" : 977
    , "upsih" : 978
    , "piv" : 982
    , "ensp" : 8194
    , "emsp" : 8195
    , "thinsp" : 8201
    , "zwnj" : 8204
    , "zwj" : 8205
    , "lrm" : 8206
    , "rlm" : 8207
    , "ndash" : 8211
    , "mdash" : 8212
    , "lsquo" : 8216
    , "rsquo" : 8217
    , "sbquo" : 8218
    , "ldquo" : 8220
    , "rdquo" : 8221
    , "bdquo" : 8222
    , "dagger" : 8224
    , "Dagger" : 8225
    , "bull" : 8226
    , "hellip" : 8230
    , "permil" : 8240
    , "prime" : 8242
    , "Prime" : 8243
    , "lsaquo" : 8249
    , "rsaquo" : 8250
    , "oline" : 8254
    , "frasl" : 8260
    , "euro" : 8364
    , "image" : 8465
    , "weierp" : 8472
    , "real" : 8476
    , "trade" : 8482
    , "alefsym" : 8501
    , "larr" : 8592
    , "uarr" : 8593
    , "rarr" : 8594
    , "darr" : 8595
    , "harr" : 8596
    , "crarr" : 8629
    , "lArr" : 8656
    , "uArr" : 8657
    , "rArr" : 8658
    , "dArr" : 8659
    , "hArr" : 8660
    , "forall" : 8704
    , "part" : 8706
    , "exist" : 8707
    , "empty" : 8709
    , "nabla" : 8711
    , "isin" : 8712
    , "notin" : 8713
    , "ni" : 8715
    , "prod" : 8719
    , "sum" : 8721
    , "minus" : 8722
    , "lowast" : 8727
    , "radic" : 8730
    , "prop" : 8733
    , "infin" : 8734
    , "ang" : 8736
    , "and" : 8743
    , "or" : 8744
    , "cap" : 8745
    , "cup" : 8746
    , "int" : 8747
    , "there4" : 8756
    , "sim" : 8764
    , "cong" : 8773
    , "asymp" : 8776
    , "ne" : 8800
    , "equiv" : 8801
    , "le" : 8804
    , "ge" : 8805
    , "sub" : 8834
    , "sup" : 8835
    , "nsub" : 8836
    , "sube" : 8838
    , "supe" : 8839
    , "oplus" : 8853
    , "otimes" : 8855
    , "perp" : 8869
    , "sdot" : 8901
    , "lceil" : 8968
    , "rceil" : 8969
    , "lfloor" : 8970
    , "rfloor" : 8971
    , "lang" : 9001
    , "rang" : 9002
    , "loz" : 9674
    , "spades" : 9824
    , "clubs" : 9827
    , "hearts" : 9829
    , "diams" : 9830
    }
    
    Object.keys(sax.ENTITIES).forEach(function (key) {
        var e = sax.ENTITIES[key]
        var s = typeof e === 'number' ? String.fromCharCode(e) : e
        sax.ENTITIES[key] = s
    })
    
    for (var S in sax.STATE) sax.STATE[sax.STATE[S]] = S
    
    // shorthand
    S = sax.STATE
    
    function emit (parser, event, data) {
      parser[event] && parser[event](data)
    }
    
    function emitNode (parser, nodeType, data) {
      if (parser.textNode) closeText(parser)
      emit(parser, nodeType, data)
    }
    
    function closeText (parser) {
      parser.textNode = textopts(parser.opt, parser.textNode)
      if (parser.textNode) emit(parser, "ontext", parser.textNode)
      parser.textNode = ""
    }
    
    function textopts (opt, text) {
      if (opt.trim) text = text.trim()
      if (opt.normalize) text = text.replace(/\s+/g, " ")
      return text
    }
    
    function error (parser, er) {
      closeText(parser)
      if (parser.trackPosition) {
        er += "\nLine: "+parser.line+
              "\nColumn: "+parser.column+
              "\nChar: "+parser.c
      }
      er = new Error(er)
      parser.error = er
      emit(parser, "onerror", er)
      return parser
    }
    
    function end (parser) {
      if (!parser.closedRoot) strictFail(parser, "Unclosed root tag")
      if ((parser.state !== S.BEGIN) && (parser.state !== S.TEXT)) error(parser, "Unexpected end")
      closeText(parser)
      parser.c = ""
      parser.closed = true
      emit(parser, "onend")
      SAXParser.call(parser, parser.strict, parser.opt)
      return parser
    }
    
    function strictFail (parser, message) {
      if (typeof parser !== 'object' || !(parser instanceof SAXParser))
        throw new Error('bad call to strictFail');
      if (parser.strict) error(parser, message)
    }
    
    function newTag (parser) {
      if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
      var parent = parser.tags[parser.tags.length - 1] || parser
        , tag = parser.tag = { name : parser.tagName, attributes : {} }
    
      // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
      if (parser.opt.xmlns) tag.ns = parent.ns
      parser.attribList.length = 0
    }
    
    function qname (name, attribute) {
      var i = name.indexOf(":")
        , qualName = i < 0 ? [ "", name ] : name.split(":")
        , prefix = qualName[0]
        , local = qualName[1]
    
      // <x "xmlns"="http://foo">
      if (attribute && name === "xmlns") {
        prefix = "xmlns"
        local = ""
      }
    
      return { prefix: prefix, local: local }
    }
    
    function attrib (parser) {
      if (!parser.strict) parser.attribName = parser.attribName[parser.looseCase]()
    
      if (parser.attribList.indexOf(parser.attribName) !== -1 ||
          parser.tag.attributes.hasOwnProperty(parser.attribName)) {
        return parser.attribName = parser.attribValue = ""
      }
    
      if (parser.opt.xmlns) {
        var qn = qname(parser.attribName, true)
          , prefix = qn.prefix
          , local = qn.local
    
        if (prefix === "xmlns") {
          // namespace binding attribute; push the binding into scope
          if (local === "xml" && parser.attribValue !== XML_NAMESPACE) {
            strictFail( parser
                      , "xml: prefix must be bound to " + XML_NAMESPACE + "\n"
                      + "Actual: " + parser.attribValue )
          } else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) {
            strictFail( parser
                      , "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\n"
                      + "Actual: " + parser.attribValue )
          } else {
            var tag = parser.tag
              , parent = parser.tags[parser.tags.length - 1] || parser
            if (tag.ns === parent.ns) {
              tag.ns = Object.create(parent.ns)
            }
            tag.ns[local] = parser.attribValue
          }
        }
    
        // defer onattribute events until all attributes have been seen
        // so any new bindings can take effect; preserve attribute order
        // so deferred events can be emitted in document order
        parser.attribList.push([parser.attribName, parser.attribValue])
      } else {
        // in non-xmlns mode, we can emit the event right away
        parser.tag.attributes[parser.attribName] = parser.attribValue
        emitNode( parser
                , "onattribute"
                , { name: parser.attribName
                  , value: parser.attribValue } )
      }
    
      parser.attribName = parser.attribValue = ""
    }
    
    function openTag (parser, selfClosing) {
      if (parser.opt.xmlns) {
        // emit namespace binding events
        var tag = parser.tag
    
        // add namespace info to tag
        var qn = qname(parser.tagName)
        tag.prefix = qn.prefix
        tag.local = qn.local
        tag.uri = tag.ns[qn.prefix] || ""
    
        if (tag.prefix && !tag.uri) {
          strictFail(parser, "Unbound namespace prefix: "
                           + JSON.stringify(parser.tagName))
          tag.uri = qn.prefix
        }
    
        var parent = parser.tags[parser.tags.length - 1] || parser
        if (tag.ns && parent.ns !== tag.ns) {
          Object.keys(tag.ns).forEach(function (p) {
            emitNode( parser
                    , "onopennamespace"
                    , { prefix: p , uri: tag.ns[p] } )
          })
        }
    
        // handle deferred onattribute events
        // Note: do not apply default ns to attributes:
        //   http://www.w3.org/TR/REC-xml-names/#defaulting
        for (var i = 0, l = parser.attribList.length; i < l; i ++) {
          var nv = parser.attribList[i]
          var name = nv[0]
            , value = nv[1]
            , qualName = qname(name, true)
            , prefix = qualName.prefix
            , local = qualName.local
            , uri = prefix == "" ? "" : (tag.ns[prefix] || "")
            , a = { name: name
                  , value: value
                  , prefix: prefix
                  , local: local
                  , uri: uri
                  }
    
          // if there's any attributes with an undefined namespace,
          // then fail on them now.
          if (prefix && prefix != "xmlns" && !uri) {
            strictFail(parser, "Unbound namespace prefix: "
                             + JSON.stringify(prefix))
            a.uri = prefix
          }
          parser.tag.attributes[name] = a
          emitNode(parser, "onattribute", a)
        }
        parser.attribList.length = 0
      }
    
      parser.tag.isSelfClosing = !!selfClosing
    
      // process the tag
      parser.sawRoot = true
      parser.tags.push(parser.tag)
      emitNode(parser, "onopentag", parser.tag)
      if (!selfClosing) {
        // special case for <script> in non-strict mode.
        if (!parser.noscript && parser.tagName.toLowerCase() === "script") {
          parser.state = S.SCRIPT
        } else {
          parser.state = S.TEXT
        }
        parser.tag = null
        parser.tagName = ""
      }
      parser.attribName = parser.attribValue = ""
      parser.attribList.length = 0
    }
    
    function closeTag (parser) {
      if (!parser.tagName) {
        strictFail(parser, "Weird empty close tag.")
        parser.textNode += "</>"
        parser.state = S.TEXT
        return
      }
    
      if (parser.script) {
        if (parser.tagName !== "script") {
          parser.script += "</" + parser.tagName + ">"
          parser.tagName = ""
          parser.state = S.SCRIPT
          return
        }
        emitNode(parser, "onscript", parser.script)
        parser.script = ""
      }
    
      // first make sure that the closing tag actually exists.
      // <a><b></c></b></a> will close everything, otherwise.
      var t = parser.tags.length
      var tagName = parser.tagName
      if (!parser.strict) tagName = tagName[parser.looseCase]()
      var closeTo = tagName
      while (t --) {
        var close = parser.tags[t]
        if (close.name !== closeTo) {
          // fail the first time in strict mode
          strictFail(parser, "Unexpected close tag")
        } else break
      }
    
      // didn't find it.  we already failed for strict, so just abort.
      if (t < 0) {
        strictFail(parser, "Unmatched closing tag: "+parser.tagName)
        parser.textNode += "</" + parser.tagName + ">"
        parser.state = S.TEXT
        return
      }
      parser.tagName = tagName
      var s = parser.tags.length
      while (s --> t) {
        var tag = parser.tag = parser.tags.pop()
        parser.tagName = parser.tag.name
        emitNode(parser, "onclosetag", parser.tagName)
    
        var x = {}
        for (var i in tag.ns) x[i] = tag.ns[i]
    
        var parent = parser.tags[parser.tags.length - 1] || parser
        if (parser.opt.xmlns && tag.ns !== parent.ns) {
          // remove namespace bindings introduced by tag
          Object.keys(tag.ns).forEach(function (p) {
            var n = tag.ns[p]
            emitNode(parser, "onclosenamespace", { prefix: p, uri: n })
          })
        }
      }
      if (t === 0) parser.closedRoot = true
      parser.tagName = parser.attribValue = parser.attribName = ""
      parser.attribList.length = 0
      parser.state = S.TEXT
    }
    
    function parseEntity (parser) {
      var entity = parser.entity
        , entityLC = entity.toLowerCase()
        , num
        , numStr = ""
      if (parser.ENTITIES[entity])
        return parser.ENTITIES[entity]
      if (parser.ENTITIES[entityLC])
        return parser.ENTITIES[entityLC]
      entity = entityLC
      if (entity.charAt(0) === "#") {
        if (entity.charAt(1) === "x") {
          entity = entity.slice(2)
          num = parseInt(entity, 16)
          numStr = num.toString(16)
        } else {
          entity = entity.slice(1)
          num = parseInt(entity, 10)
          numStr = num.toString(10)
        }
      }
      entity = entity.replace(/^0+/, "")
      if (numStr.toLowerCase() !== entity) {
        strictFail(parser, "Invalid character entity")
        return "&"+parser.entity + ";"
      }
      return String.fromCharCode(num)
    }
    
    function write (chunk) {
      var parser = this
      if (this.error) throw this.error
      if (parser.closed) return error(parser,
        "Cannot write after close. Assign an onready handler.")
      if (chunk === null) return end(parser)
      var i = 0, c = ""
      while (parser.c = c = chunk.charAt(i++)) {
        if (parser.trackPosition) {
          parser.position ++
          if (c === "\n") {
            parser.line ++
            parser.column = 0
          } else parser.column ++
        }
        switch (parser.state) {
    
          case S.BEGIN:
            if (c === "<") {
              parser.state = S.OPEN_WAKA
              parser.startTagPosition = parser.position
            } else if (not(whitespace,c)) {
              // have to process this as a text node.
              // weird, but happens.
              strictFail(parser, "Non-whitespace before first tag.")
              parser.textNode = c
              parser.state = S.TEXT
            }
          continue
    
          case S.TEXT:
            if (parser.sawRoot && !parser.closedRoot) {
              var starti = i-1
              while (c && c!=="<" && c!=="&") {
                c = chunk.charAt(i++)
                if (c && parser.trackPosition) {
                  parser.position ++
                  if (c === "\n") {
                    parser.line ++
                    parser.column = 0
                  } else parser.column ++
                }
              }
              parser.textNode += chunk.substring(starti, i-1)
            }
            if (c === "<") {
              parser.state = S.OPEN_WAKA
              parser.startTagPosition = parser.position
            } else {
              if (not(whitespace, c) && (!parser.sawRoot || parser.closedRoot))
                strictFail(parser, "Text data outside of root node.")
              if (c === "&") parser.state = S.TEXT_ENTITY
              else parser.textNode += c
            }
          continue
    
          case S.SCRIPT:
            // only non-strict
            if (c === "<") {
              parser.state = S.SCRIPT_ENDING
            } else parser.script += c
          continue
    
          case S.SCRIPT_ENDING:
            if (c === "/") {
              parser.state = S.CLOSE_TAG
            } else {
              parser.script += "<" + c
              parser.state = S.SCRIPT
            }
          continue
    
          case S.OPEN_WAKA:
            // either a /, ?, !, or text is coming next.
            if (c === "!") {
              parser.state = S.SGML_DECL
              parser.sgmlDecl = ""
            } else if (is(whitespace, c)) {
              // wait for it...
            } else if (is(nameStart,c)) {
              parser.state = S.OPEN_TAG
              parser.tagName = c
            } else if (c === "/") {
              parser.state = S.CLOSE_TAG
              parser.tagName = ""
            } else if (c === "?") {
              parser.state = S.PROC_INST
              parser.procInstName = parser.procInstBody = ""
            } else {
              strictFail(parser, "Unencoded <")
              // if there was some whitespace, then add that in.
              if (parser.startTagPosition + 1 < parser.position) {
                var pad = parser.position - parser.startTagPosition
                c = new Array(pad).join(" ") + c
              }
              parser.textNode += "<" + c
              parser.state = S.TEXT
            }
          continue
    
          case S.SGML_DECL:
            if ((parser.sgmlDecl+c).toUpperCase() === CDATA) {
              emitNode(parser, "onopencdata")
              parser.state = S.CDATA
              parser.sgmlDecl = ""
              parser.cdata = ""
            } else if (parser.sgmlDecl+c === "--") {
              parser.state = S.COMMENT
              parser.comment = ""
              parser.sgmlDecl = ""
            } else if ((parser.sgmlDecl+c).toUpperCase() === DOCTYPE) {
              parser.state = S.DOCTYPE
              if (parser.doctype || parser.sawRoot) strictFail(parser,
                "Inappropriately located doctype declaration")
              parser.doctype = ""
              parser.sgmlDecl = ""
            } else if (c === ">") {
              emitNode(parser, "onsgmldeclaration", parser.sgmlDecl)
              parser.sgmlDecl = ""
              parser.state = S.TEXT
            } else if (is(quote, c)) {
              parser.state = S.SGML_DECL_QUOTED
              parser.sgmlDecl += c
            } else parser.sgmlDecl += c
          continue
    
          case S.SGML_DECL_QUOTED:
            if (c === parser.q) {
              parser.state = S.SGML_DECL
              parser.q = ""
            }
            parser.sgmlDecl += c
          continue
    
          case S.DOCTYPE:
            if (c === ">") {
              parser.state = S.TEXT
              emitNode(parser, "ondoctype", parser.doctype)
              parser.doctype = true // just remember that we saw it.
            } else {
              parser.doctype += c
              if (c === "[") parser.state = S.DOCTYPE_DTD
              else if (is(quote, c)) {
                parser.state = S.DOCTYPE_QUOTED
                parser.q = c
              }
            }
          continue
    
          case S.DOCTYPE_QUOTED:
            parser.doctype += c
            if (c === parser.q) {
              parser.q = ""
              parser.state = S.DOCTYPE
            }
          continue
    
          case S.DOCTYPE_DTD:
            parser.doctype += c
            if (c === "]") parser.state = S.DOCTYPE
            else if (is(quote,c)) {
              parser.state = S.DOCTYPE_DTD_QUOTED
              parser.q = c
            }
          continue
    
          case S.DOCTYPE_DTD_QUOTED:
            parser.doctype += c
            if (c === parser.q) {
              parser.state = S.DOCTYPE_DTD
              parser.q = ""
            }
          continue
    
          case S.COMMENT:
            if (c === "-") parser.state = S.COMMENT_ENDING
            else parser.comment += c
          continue
    
          case S.COMMENT_ENDING:
            if (c === "-") {
              parser.state = S.COMMENT_ENDED
              parser.comment = textopts(parser.opt, parser.comment)
              if (parser.comment) emitNode(parser, "oncomment", parser.comment)
              parser.comment = ""
            } else {
              parser.comment += "-" + c
              parser.state = S.COMMENT
            }
          continue
    
          case S.COMMENT_ENDED:
            if (c !== ">") {
              strictFail(parser, "Malformed comment")
              // allow <!-- blah -- bloo --> in non-strict mode,
              // which is a comment of " blah -- bloo "
              parser.comment += "--" + c
              parser.state = S.COMMENT
            } else parser.state = S.TEXT
          continue
    
          case S.CDATA:
            if (c === "]") parser.state = S.CDATA_ENDING
            else parser.cdata += c
          continue
    
          case S.CDATA_ENDING:
            if (c === "]") parser.state = S.CDATA_ENDING_2
            else {
              parser.cdata += "]" + c
              parser.state = S.CDATA
            }
          continue
    
          case S.CDATA_ENDING_2:
            if (c === ">") {
              if (parser.cdata) emitNode(parser, "oncdata", parser.cdata)
              emitNode(parser, "onclosecdata")
              parser.cdata = ""
              parser.state = S.TEXT
            } else if (c === "]") {
              parser.cdata += "]"
            } else {
              parser.cdata += "]]" + c
              parser.state = S.CDATA
            }
          continue
    
          case S.PROC_INST:
            if (c === "?") parser.state = S.PROC_INST_ENDING
            else if (is(whitespace, c)) parser.state = S.PROC_INST_BODY
            else parser.procInstName += c
          continue
    
          case S.PROC_INST_BODY:
            if (!parser.procInstBody && is(whitespace, c)) continue
            else if (c === "?") parser.state = S.PROC_INST_ENDING
            else parser.procInstBody += c
          continue
    
          case S.PROC_INST_ENDING:
            if (c === ">") {
              emitNode(parser, "onprocessinginstruction", {
                name : parser.procInstName,
                body : parser.procInstBody
              })
              parser.procInstName = parser.procInstBody = ""
              parser.state = S.TEXT
            } else {
              parser.procInstBody += "?" + c
              parser.state = S.PROC_INST_BODY
            }
          continue
    
          case S.OPEN_TAG:
            if (is(nameBody, c)) parser.tagName += c
            else {
              newTag(parser)
              if (c === ">") openTag(parser)
              else if (c === "/") parser.state = S.OPEN_TAG_SLASH
              else {
                if (not(whitespace, c)) strictFail(
                  parser, "Invalid character in tag name")
                parser.state = S.ATTRIB
              }
            }
          continue
    
          case S.OPEN_TAG_SLASH:
            if (c === ">") {
              openTag(parser, true)
              closeTag(parser)
            } else {
              strictFail(parser, "Forward-slash in opening tag not followed by >")
              parser.state = S.ATTRIB
            }
          continue
    
          case S.ATTRIB:
            // haven't read the attribute name yet.
            if (is(whitespace, c)) continue
            else if (c === ">") openTag(parser)
            else if (c === "/") parser.state = S.OPEN_TAG_SLASH
            else if (is(nameStart, c)) {
              parser.attribName = c
              parser.attribValue = ""
              parser.state = S.ATTRIB_NAME
            } else strictFail(parser, "Invalid attribute name")
          continue
    
          case S.ATTRIB_NAME:
            if (c === "=") parser.state = S.ATTRIB_VALUE
            else if (c === ">") {
              strictFail(parser, "Attribute without value")
              parser.attribValue = parser.attribName
              attrib(parser)
              openTag(parser)
            }
            else if (is(whitespace, c)) parser.state = S.ATTRIB_NAME_SAW_WHITE
            else if (is(nameBody, c)) parser.attribName += c
            else strictFail(parser, "Invalid attribute name")
          continue
    
          case S.ATTRIB_NAME_SAW_WHITE:
            if (c === "=") parser.state = S.ATTRIB_VALUE
            else if (is(whitespace, c)) continue
            else {
              strictFail(parser, "Attribute without value")
              parser.tag.attributes[parser.attribName] = ""
              parser.attribValue = ""
              emitNode(parser, "onattribute",
                       { name : parser.attribName, value : "" })
              parser.attribName = ""
              if (c === ">") openTag(parser)
              else if (is(nameStart, c)) {
                parser.attribName = c
                parser.state = S.ATTRIB_NAME
              } else {
                strictFail(parser, "Invalid attribute name")
                parser.state = S.ATTRIB
              }
            }
          continue
    
          case S.ATTRIB_VALUE:
            if (is(whitespace, c)) continue
            else if (is(quote, c)) {
              parser.q = c
              parser.state = S.ATTRIB_VALUE_QUOTED
            } else {
              strictFail(parser, "Unquoted attribute value")
              parser.state = S.ATTRIB_VALUE_UNQUOTED
              parser.attribValue = c
            }
          continue
    
          case S.ATTRIB_VALUE_QUOTED:
            if (c !== parser.q) {
              if (c === "&") parser.state = S.ATTRIB_VALUE_ENTITY_Q
              else parser.attribValue += c
              continue
            }
            attrib(parser)
            parser.q = ""
            parser.state = S.ATTRIB_VALUE_CLOSED
          continue
    
          case S.ATTRIB_VALUE_CLOSED:
            if (is(whitespace, c)) {
              parser.state = S.ATTRIB
            } else if (c === ">") openTag(parser)
            else if (c === "/") parser.state = S.OPEN_TAG_SLASH
            else if (is(nameStart, c)) {
              strictFail(parser, "No whitespace between attributes")
              parser.attribName = c
              parser.attribValue = ""
              parser.state = S.ATTRIB_NAME
            } else strictFail(parser, "Invalid attribute name")
          continue
    
          case S.ATTRIB_VALUE_UNQUOTED:
            if (not(attribEnd,c)) {
              if (c === "&") parser.state = S.ATTRIB_VALUE_ENTITY_U
              else parser.attribValue += c
              continue
            }
            attrib(parser)
            if (c === ">") openTag(parser)
            else parser.state = S.ATTRIB
          continue
    
          case S.CLOSE_TAG:
            if (!parser.tagName) {
              if (is(whitespace, c)) continue
              else if (not(nameStart, c)) {
                if (parser.script) {
                  parser.script += "</" + c
                  parser.state = S.SCRIPT
                } else {
                  strictFail(parser, "Invalid tagname in closing tag.")
                }
              } else parser.tagName = c
            }
            else if (c === ">") closeTag(parser)
            else if (is(nameBody, c)) parser.tagName += c
            else if (parser.script) {
              parser.script += "</" + parser.tagName
              parser.tagName = ""
              parser.state = S.SCRIPT
            } else {
              if (not(whitespace, c)) strictFail(parser,
                "Invalid tagname in closing tag")
              parser.state = S.CLOSE_TAG_SAW_WHITE
            }
          continue
    
          case S.CLOSE_TAG_SAW_WHITE:
            if (is(whitespace, c)) continue
            if (c === ">") closeTag(parser)
            else strictFail(parser, "Invalid characters in closing tag")
          continue
    
          case S.TEXT_ENTITY:
          case S.ATTRIB_VALUE_ENTITY_Q:
          case S.ATTRIB_VALUE_ENTITY_U:
            switch(parser.state) {
              case S.TEXT_ENTITY:
                var returnState = S.TEXT, buffer = "textNode"
              break
    
              case S.ATTRIB_VALUE_ENTITY_Q:
                var returnState = S.ATTRIB_VALUE_QUOTED, buffer = "attribValue"
              break
    
              case S.ATTRIB_VALUE_ENTITY_U:
                var returnState = S.ATTRIB_VALUE_UNQUOTED, buffer = "attribValue"
              break
            }
            if (c === ";") {
              parser[buffer] += parseEntity(parser)
              parser.entity = ""
              parser.state = returnState
            }
            else if (is(entity, c)) parser.entity += c
            else {
              strictFail(parser, "Invalid character entity")
              parser[buffer] += "&" + parser.entity + c
              parser.entity = ""
              parser.state = returnState
            }
          continue
    
          default:
            throw new Error(parser, "Unknown state: " + parser.state)
        }
      } // while
      // cdata blocks can get very big under normal conditions. emit and move on.
      // if (parser.state === S.CDATA && parser.cdata) {
      //   emitNode(parser, "oncdata", parser.cdata)
      //   parser.cdata = ""
      // }
      if (parser.position >= parser.bufferCheckPosition) checkBufferLength(parser)
      return parser
    }
    
    })(typeof exports === "undefined" ? sax = {} : exports)

    var saxparser = sax.parser(true);

    function g_parse(xmlString) {
        var object = null;
        var namespaces = {};
        var hasError = false;
        saxparser.onerror = function (err) {
            hasError = true;
        };
        saxparser.onopentag = function (node) {
            var attribs = node.attributes;
            
            // delete node["attributes"];
            if(!node["children"]){
                node["children"] = []
            }

            for (var key in attribs) {
                index = key.indexOf("xmlns:");
                if (index == 0) {
                    var prefix = key.substring(6);
                    var uri = attribs[key];
                    namespaces[prefix] = uri;
                    delete attribs[key];
                }
                else{
                    node["$"+key] = attribs[key];
                }
            }
            node.text = "";
            node.toString = toString;
            var name = node.name;
            var index = name.indexOf(":");
            if (index == -1) {
                node.namespace = "";
                node.prefix = "";
                node.localName = name;
            } else {
                var prefix = name.substring(0, index);
                node.prefix = prefix;
                node.namespace = namespaces[prefix];
                node.localName = name.substring(index + 1);
            }
            if (object) {
                var children = object.children;
                if (!children) {
                    children = object.children = [];
                    if (object.text) {
                        object.text = "";
                    }
                }
                children.push(node);
                node.parent = object;
                object = node;
            } else {
                object = node;
            }
        };

        saxparser.onclosetag = function (node) {
            if (object.parent)
                object = object.parent;
        };

        saxparser.oncdata = function (cdata) {
            if (object && !object.children)
                object.text = cdata;
        };

        saxparser.ontext = function (text) {
            if (object && !object.text && !object.children)
                object.text = text;
        };

        saxparser.write(xmlString).close();

        if (hasError) {
            return null;
        } else {
            return object;
        }
    };

    function toString(){
        return this.text;
    };

    export class XML{
        public static parse(str){
            return g_parse(str)
        }
    }
}